class Evaluado < ActiveRecord::Base
  has_many :planes_acciones, :as=>:clase
  
  #before_destroy :delete_all_data

  belongs_to :usuario
  belongs_to :evaluacion
  belongs_to :evaluado, :class_name => "Usuario", :foreign_key => :evaluado_id

  # after_destroy :borrar_respuestas

  validates_uniqueness_of :usuario_id, :scope => [:evaluado_id, :evaluacion_id]
  validates_presence_of :conclucion,:message => "Para terminar la evaluacion debe escribir una conclucion.", :if => Proc.new {|evaluado|
    evaluado.usuario.respuestas.por_evaluacion_y_evaluado(evaluado.evaluacion,evaluado.evaluado).count==evaluado.evaluado.preguntas.por_evaluacion(evaluado.evaluacion).count
  }
  named_scope :por_evaluacion, lambda {|evaluacion_id| {:conditions => ["evaluacion_id = ?", evaluacion_id]}} 
  named_scope :por_evaluacion_y_tipo_evaluado, lambda {|evaluacion,tipo| {:conditions => ["evaluacion_id = ? and tipo like '%#{tipo}%'", evaluacion.id]}}
  named_scope :por_tipo, lambda {|tipo| {:conditions => ["tipo = ? AND evaluado_id <> usuario_id", tipo]}} 
  named_scope :distintos, :select=>"DISTINCT(evaluado_id)"
  named_scope :por_evaluado_id, lambda {|id| {:conditions => ["evaluado_id = ?",id]}}

  def nombre_para_plan_accion
    self.nombre<<', evaluado por '<<self.usuario.nombre
  end
  
  def cargo
    self.evaluado.datos.find_by_evaluacion_id(self.evaluacion_id).try(:cargo)
  end

  def area
    self.evaluado.datos.find_by_evaluacion_id(self.evaluacion_id).try(:area)
  end

  def nombre
    self.evaluacion.nombre
  end

  def desempenio_en_palabras
    case self.desempenio.to_i
    when 0..60
      "Desempeño no satisfactorio"
    when 61..74
      "Desempeño normal / bueno"
    when 75..89
      "Desempeño muy bueno"
    when 90..100
      "Excelente desempeño"
    end
  end



  def usuario_evaluado
    Usuario.find self.evaluado_id
  end

  def usuario_evaluador
    Usuario.find self.usuario_id
  end

  def self.crear_evaluacion_para(usuario_evaluador, respuestas)
    evaluacion = Evaluacion.find respuestas[:evaluacion_id]
    usuario_evaluado = Usuario.find respuestas[:usuario_evaluado_id]
    tipo_evaluado=self.en_relacion_con(usuario_evaluado,usuario_evaluador,evaluacion)
    valid      = []
    respuestas[:pregunta].each do |d|
      valid << nueva_respuesta(d[1]["respuesta"], usuario_evaluador,usuario_evaluado,tipo_evaluado) if d[1]["respuesta"]["valor"]
    end
    valid.all? { |guardado| guardado == true}
  end

  def self.actualizar_evaluacion_para(usuario_evaluador, params)
    evaluacion = Evaluacion.find params[:evaluacion_id].to_i
    usuario_evaluado = Usuario.find params[:usuario_evaluado_id].to_i
    respuestas={}
    usuario_evaluador.respuestas.por_evaluacion_y_evaluado(evaluacion,usuario_evaluado).each do |respuesta|
      respuestas[respuesta.pregunta_id.to_s]=respuesta
    end
    pregunta_ids=respuestas.keys
    valid      = []
    params[:pregunta].each do |datos|
      datos[1]["respuesta"].delete("id")
      pregunta_id=datos[0]
      if pregunta_ids.include?(pregunta_id)
        respuestas[pregunta_id].update_attributes(datos[1]["respuesta"])
        valid << (g = respuestas[pregunta_id].save)
      else
        valid << (g = self.nueva_respuesta(datos[1]["respuesta"], usuario_evaluador,usuario_evaluado,respuestas[pregunta_ids[0]].tipo_evaluado )) if datos[1]["respuesta"]["valor"]
      end
    end
    valido = valid.all? { |guardado| guardado == true}
    valido
  end

  #Competencias del usuario evaluado
  def competencias_especificas
    if usuario_evaluado
      usuario_evaluado.cargo.competencias if usuario_evaluado.cargo
    end
  end

  def respuestas
    rsp = []
    evaluacion.preguntas.each do |pregunta|
      pregunta.respuestas.evaluador(self.usuario_id).evaluado(self.evaluado_id).each do |respuesta|
        rsp << respuesta
      end
    end
    rsp
  end

  def respuesta(pregunta)
    pregunta.respuestas.find(:first, :conditions => ['usuario_id = ? AND evaluado_id = ?', self.usuario_id, self.evaluado_id ])
  end

  ##yeap el campo conclucion esta mal escrito
  def self.find_all_conclusiones(usuario_evaluado, evaluacion)
    self.find(:all, :conditions => ['evaluado_id = ? AND evaluacion_id = ?', usuario_evaluado.id, evaluacion.id ]).map(&:conclucion).flatten
  end

  private
  def delete_all_data
    #Borra la relacion con las preguntas de la evaluacion a la que pertenece
    ids=self.evaluado.usuarios_preguntas.por_evaluacion(self.evaluacion).map(&:id)
    cant=UsuarioPregunta.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    #Borra los datos almacenados para esta evaluacion
    ids=self.evaluado.datos.por_evaluacion(self.evaluacion).map(&:id)
    cant=UsuarioDato.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    #Borra los resultados por competencias para la evaluacion a la que pertenece
    ids=self.evaluado.resultados_competencias.por_evaluacion(self.evaluacion).map(&:id)
    cant=ResultadoCompetencia.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
    #Borra los resultados por competencias para la evaluacion a la que pertenece
    ids=Evaluado.por_evaluacion(self.evaluacion_id).find_all_by_evaluado_id(self.evaluado_id).map(&:id)
    ids.delete(self.id)
    cant=Evaluado.delete_all("id IN (#{ids.join(",")})") unless ids.empty?
  end


  def self.nueva_respuesta(respuesta, evaluador, evaluado,tipo_evaluado)
    rtn = true
    respuesta_new                = Respuesta.new
    respuesta_new.evaluado_id    = evaluado.id
    respuesta_new.usuario_id     = evaluador.id
    respuesta_new.pregunta_id    = respuesta["pregunta_id"].to_i
    respuesta_new.comentario     = respuesta["comentario"]
    respuesta_new.valor          = respuesta["valor"]
    respuesta_new.tipo_evaluado  = tipo_evaluado
    rtn                      = respuesta_new.save
    rtn
  end

  def self.en_relacion_con(evaluado, evaluador,evaluacion)
    if evaluado.id == evaluador.id
      "autoevaluacion"
    else
      evaluado = evaluador.evaluados.find_by_evaluado_id_and_usuario_id_and_evaluacion_id(evaluado.id,evaluador.id,evaluacion.id)
      evaluado.tipo if evaluado
    end
  end

  def borrar_respuestas
    Respuesta.delete_all("evaluado_id = #{self.evaluado_id} AND usuario_id = #{@usuario.id}")
  end

  def self.find_all_by_tipo(evaluacion, evaluado, tipo = nil)
    if tipo
      find(:all, :conditions => ['evaluacion_id = ? AND evaluado_id <> ? AND tipo = ?', evaluacion.id, evaluado.id, tipo])
    else
      find(:all, :conditions => ['evaluacion_id = ? AND evaluado_id = ?', evaluacion.id, evaluado.id])
    end
  end

end
